//本文件由程序自动生成,请不要自行修改
using System;
using fastCSharp;

#if NotFastCSharpCode
#else
#pragma warning disable
namespace diantou.examImageServer
{
        public partial class server : fastCSharp.code.cSharp.tcpServer.ICommandServer
        {

            /// <summary>
            /// ExamImage TCP服务
            /// </summary>
            public sealed class tcpServer : fastCSharp.net.tcp.commandServer
            {
                private readonly diantou.examImageServer.server _value_;
                /// <summary>
                /// ExamImage TCP调用服务端
                /// </summary>
                /// <param name="attribute">TCP调用服务器端配置信息</param>
                /// <param name="value">TCP服务目标对象</param>
                public tcpServer(fastCSharp.code.cSharp.tcpServer attribute = null, diantou.examImageServer.server value = null)
                    : base(attribute ?? fastCSharp.code.cSharp.tcpServer.GetConfig("ExamImage", typeof(diantou.examImageServer.server)))
                {
                    _value_ = value ?? new diantou.examImageServer.server();
                    setCommands(4);
                    identityOnCommands[0 + 128].Set(0 + 128);
                    identityOnCommands[1 + 128].Set(1 + 128);
                    identityOnCommands[2 + 128].Set(2 + 128);
                    identityOnCommands[verifyCommandIdentity = 3 + 128].Set(3 + 128, 1024);
                    _value_.SetCommandServer(this);
                }
                /// <summary>
                /// 命令处理
                /// </summary>
                /// <param name="index"></param>
                /// <param name="socket"></param>
                /// <param name="data"></param>
                protected override void doCommand(int index, socket socket, ref subArray<byte> data)
                {
                    if (index < 128) base.doCommand(index, socket, ref data);
                    else
                    {
                        switch (index - 128)
                        {
                            case 0: _M0(socket, ref data); return;
                            case 1: _M1(socket, ref data); return;
                            case 2: _M2(socket, ref data); return;
                            case 3: _M3(socket, ref data); return;
                            default: return;
                        }
                    }
                }

                [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
                internal struct _i0
                {
                    public int userId;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o0 : fastCSharp.net.asynchronousMethod.IReturnParameter<int[]>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public int[] Ret;
                    public int[] Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s0 : fastCSharp.net.tcp.commandServer.serverCall<_s0, diantou.examImageServer.server, _i0>
                {
                    private fastCSharp.net.returnValue<_o0> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            int[] Return;


                            
                            Return = serverValue.getNames(inputParameter.userId);

                            return new _o0
                            {
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o0>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s0>.PushNotNull(this);
                    }
                }
                private void _M0(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i0 inputParameter = new _i0();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                fastCSharp.threading.task.Tiny.Add(_s0/**/.GetCall(socket, _value_, ref inputParameter ));
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
                internal struct _i1
                {
                    public int userId;
                    public fastCSharp.subArray<int> names;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o1 : fastCSharp.net.asynchronousMethod.IReturnParameter<byte[][]>
                {
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public byte[][] Ret;
                    public byte[][] Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s1 : fastCSharp.net.tcp.commandServer.serverCall<_s1, diantou.examImageServer.server, _i1>
                {
                    private fastCSharp.net.returnValue<_o1> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            byte[][] Return;


                            
                            Return = serverValue.get(inputParameter.userId, inputParameter.names);

                            return new _o1
                            {
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o1>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s1>.PushNotNull(this);
                    }
                }
                private void _M1(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i1 inputParameter = new _i1();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                fastCSharp.threading.task.Tiny.Add(_s1/**/.GetCall(socket, _value_, ref inputParameter ));
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false)]
                internal struct _i2
                {
                    public int userId;
                }
                sealed class _s2 : fastCSharp.net.tcp.commandServer.serverCall<_s2, diantou.examImageServer.server, _i2>
                {
                    private fastCSharp.net.returnValue get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            


                            serverValue.remove(inputParameter.userId);

                            return new fastCSharp.net.returnValue{ Type = fastCSharp.net.returnValue.type.Success };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s2>.PushNotNull(this);
                    }
                }
                private void _M2(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i2 inputParameter = new _i2();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                fastCSharp.threading.task.Tiny.Add(_s2/**/.GetCall(socket, _value_, ref inputParameter ));
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                internal struct _i3
                {
                    public ulong randomPrefix;
                    public byte[] md5Data;
                    public long ticks;
                }
                [fastCSharp.emit.dataSerialize(IsMemberMap = false, IsReferenceMember = false)]
                [fastCSharp.emit.boxSerialize]
                internal struct _o3 : fastCSharp.net.asynchronousMethod.IReturnParameter<bool>
                {
                    public long ticks;
                    [fastCSharp.emit.jsonSerialize.member(IsIgnoreCurrent = true)]
                    [fastCSharp.emit.jsonParse.member(IsIgnoreCurrent = true)]
                    public bool Ret;
                    public bool Return
                    {
                        get { return Ret; }
                        set { Ret = value; }
                    }
                }
                sealed class _s3 : fastCSharp.net.tcp.commandServer.serverCall<_s3, diantou.examImageServer.server, _i3>
                {
                    private fastCSharp.net.returnValue<_o3> get()
                    {
                        fastCSharp.net.returnValue.type returnType;
                        try
                        {
                            
                            bool Return;


                            
                            Return = serverValue.verify(socket, inputParameter.randomPrefix, inputParameter.md5Data, ref inputParameter.ticks);

                            if (Return) socket.SetVerifyMethod();
                            return new _o3
                            {
                                ticks = inputParameter.ticks,
                                Return = Return
                            };
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                        return new fastCSharp.net.returnValue<_o3>{ Type = returnType };
                    }
                    protected override void call()
                    {
                        if (isVerify == 0) socket.SendStream(identity, flags, get());
                        fastCSharp.typePool<_s3>.PushNotNull(this);
                    }
                }
                private void _M3(socket socket, ref subArray<byte> data)
                {
                    fastCSharp.net.returnValue.type returnType = fastCSharp.net.returnValue.type.Unknown;
                        try
                        {
                            _i3 inputParameter = new _i3();
                            if ((socket.Flags & fastCSharp.net.tcp.commandServer.commandFlags.JsonSerialize) == 0 ? fastCSharp.emit.dataDeSerializer.DeSerialize(ref data, ref inputParameter) : fastCSharp.code.cSharp.tcpBase.JsonDeSerialize(ref inputParameter, ref data))
                            {
                                _s3/**/.Call(socket, _value_, ref inputParameter );
                                return;
                            }
                            returnType = fastCSharp.net.returnValue.type.ServerDeSerializeError;
                        }
                        catch (Exception error)
                        {
                            returnType = fastCSharp.net.returnValue.type.ServerException;
                            fastCSharp.log.Error.Add(error, null, true);
                        }
                    socket.SendStream(socket.Identity, new fastCSharp.net.returnValue { Type = returnType });
                }
            }

            /// <summary>
            /// TCP客户端
            /// </summary>
            public class tcpClient : fastCSharp.net.tcp.timeVerifyServer.ITimeVerifyClient, fastCSharp.net.tcp.commandClient.IClient
            {
                /// <summary>
                /// 时间验证服务客户端验证函数
                /// </summary>
                public sealed class timeVerifyMethod : fastCSharp.code.cSharp.tcpBase.ITcpClientVerifyMethod<tcpClient>
                {
                    /// <summary>
                    /// 时间验证服务客户端验证函数
                    /// </summary>
                    /// <param name="client">TCP调用客户端</param>
                    /// <returns>是否通过验证</returns>
                    public bool Verify(tcpClient client)
                    {
                        return fastCSharp.net.tcp.timeVerifyServer.Verify(client);
                    }
                }
                /// <summary>
                /// TCP调用客户端
                /// </summary>
                private fastCSharp.net.tcp.commandClient tcpCommandClient;
                /// <summary>
                /// TCP调用客户端
                /// </summary>
                public fastCSharp.net.tcp.commandClient TcpCommandClient { get { return tcpCommandClient; } }
                /// <summary>
                /// TCP调用客户端
                /// </summary>
                /// <param name="attribute">TCP调用服务器端配置信息</param>
                /// <param name="verifyMethod">TCP验证方法</param>
                public tcpClient(fastCSharp.code.cSharp.tcpServer attribute = null, fastCSharp.code.cSharp.tcpBase.ITcpClientVerifyMethod<tcpClient> verifyMethod = null)
                {
                    tcpCommandClient = new fastCSharp.net.tcp.commandClient<tcpClient>(attribute ?? fastCSharp.code.cSharp.tcpServer.GetConfig("ExamImage", typeof(diantou.examImageServer.server)), 28, verifyMethod ?? new diantou.examImageServer.server.tcpClient.timeVerifyMethod(), this);
                }
                /// <summary>
                /// 释放资源
                /// </summary>
                public void Dispose()
                {
                    fastCSharp.pub.Dispose(ref tcpCommandClient);
                }


                /// <summary>
                /// 忽略TCP分组
                /// </summary>
                /// <param name="groupId">分组标识</param>
                /// <returns>是否调用成功</returns>
                public fastCSharp.net.returnValue.type TcpIgnoreGroup(int groupId)
                {
                    fastCSharp.net.tcp.commandClient client = TcpCommandClient;
                    return client == null ? fastCSharp.net.returnValue.type.ClientDisposed : client.IgnoreGroup(groupId);
                }

                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c0 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 0 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 获取文件名称集合
                /// </summary>
                public fastCSharp.net.returnValue<int[]> getNames(int userId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o0> _wait_ = fastCSharp.net.waitCall<tcpServer._o0>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        getNames(userId, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o0> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<int[]>{ Type = _returnType_ };
                }


                private void getNames(int userId, Action<fastCSharp.net.returnValue<tcpServer._o0>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o0>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i0 _inputParameter_ = new tcpServer._i0
                            {
                                userId = userId,
                            };
                            tcpServer._o0 _outputParameter_ = new tcpServer._o0();
                            _socket_.Get(_onReturn_, _callback_, _c0, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o0>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o0>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c1 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 1 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 批量获取文件内容
                /// </summary>
                public fastCSharp.net.returnValue<byte[][]> get(int userId, fastCSharp.subArray<int> names)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o1> _wait_ = fastCSharp.net.waitCall<tcpServer._o1>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        get(userId, names, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o1> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<byte[][]>{ Type = _returnType_ };
                }


                private void get(int userId, fastCSharp.subArray<int> names, Action<fastCSharp.net.returnValue<tcpServer._o1>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o1>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i1 _inputParameter_ = new tcpServer._i1
                            {
                                userId = userId,
                                names = names,
                            };
                            tcpServer._o1 _outputParameter_ = new tcpServer._o1();
                            _socket_.Get(_onReturn_, _callback_, _c1, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o1>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o1>{ Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c2 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 2 + 128, MaxInputSize = 2147483647, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 删除文件
                /// </summary>
                public fastCSharp.net.returnValue remove(int userId)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall _wait_ = fastCSharp.net.waitCall.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        remove(userId, null, _wait_, false);
                        return _wait_.Value;
                    }
                    return new fastCSharp.net.returnValue{ Type = _returnType_ };
                }


                /// <summary>
                /// 删除文件
                /// </summary>
                [System.Runtime.CompilerServices.MethodImpl((System.Runtime.CompilerServices.MethodImplOptions)fastCSharp.pub.MethodImplOptionsAggressiveInlining)]
                public void remove(int userId, Action<fastCSharp.net.returnValue> _onReturn_)
                {
                    
                    remove(userId, _onReturn_, null, true);
                }
                private void remove(int userId, Action<fastCSharp.net.returnValue> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.StreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i2 _inputParameter_ = new tcpServer._i2
                            {
                                userId = userId,
                            };
                            _socket_.Call<tcpServer._i2>(_onReturn_, _callback_, _c2, ref _inputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue { Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue { Type = _returnType_ });
                }
                private static readonly fastCSharp.net.tcp.commandClient.identityCommand _c3 = new fastCSharp.net.tcp.commandClient.identityCommand { Command = 3 + 128, MaxInputSize = 1024, IsKeepCallback = 0, IsSendOnly = 0 };

                /// <summary>
                /// 时间验证函数
                /// </summary>
                /// <returns>是否验证成功</returns>
                public fastCSharp.net.returnValue<bool> verify(ulong randomPrefix, byte[] md5Data, ref long ticks)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    fastCSharp.net.waitCall<tcpServer._o3> _wait_ = fastCSharp.net.waitCall<tcpServer._o3>.Get();
                    if (_wait_ == null) _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                    else
                    {
                        
                        verify(randomPrefix, md5Data, ref ticks, null, _wait_, false);
                        fastCSharp.net.returnValue<tcpServer._o3> _outputParameter_ = _wait_.Value;
                        if (_outputParameter_.Type == fastCSharp.net.returnValue.type.Success)
                        {
                            ticks = _outputParameter_.Value.ticks;
                            return _outputParameter_.Value.Return;
                        }
                        _returnType_ = _outputParameter_.Type;
                    }
                    return new fastCSharp.net.returnValue<bool>{ Type = _returnType_ };
                }


                private void verify(ulong randomPrefix, byte[] md5Data, ref long ticks, Action<fastCSharp.net.returnValue<tcpServer._o3>> _onReturn_, fastCSharp.net.callback<fastCSharp.net.returnValue<tcpServer._o3>> _callback_, bool _isTask_)
                {
                    fastCSharp.net.returnValue.type _returnType_;
                    try
                    {
                        fastCSharp.net.tcp.commandClient.streamCommandSocket _socket_ = TcpCommandClient.VerifyStreamSocket;
                        if (_socket_ != null)
                        {
                            tcpServer._i3 _inputParameter_ = new tcpServer._i3
                            {
                                randomPrefix = randomPrefix,
                                md5Data = md5Data,
                                ticks = ticks,
                            };
                            tcpServer._o3 _outputParameter_ = new tcpServer._o3();
                            _outputParameter_.ticks = _inputParameter_.ticks;
                            _socket_.Get(_onReturn_, _callback_, _c3, ref _inputParameter_, _outputParameter_, _isTask_);
                            return;
                        }
                        _returnType_ = fastCSharp.net.returnValue.type.ClientDisposed;
                    }
                    catch (Exception _error_)
                    {
                        _returnType_ = fastCSharp.net.returnValue.type.ClientException;
                        fastCSharp.log.Error.Add(_error_, null, false);
                    }
                    if (_callback_ != null) _callback_.Callback(new fastCSharp.net.returnValue<tcpServer._o3>{ Type = _returnType_ });
                    else if (_onReturn_ != null) _onReturn_(new fastCSharp.net.returnValue<tcpServer._o3>{ Type = _returnType_ });
                }
            }

        }
}
#endif